Let’s Git Started

Author
Affiliation

Prof. Matthew G. Son

University of South Florida

Installation

Git installation: Windows

  1. For using Git/Github and Unix, install git bash for windows from:

https://git-scm.com/downloads

  1. Configure git, your name and email address
git config --global user.name "Your Name"
git config --global user.email "you@example.com"

git config --global --list

  1. In VScode (Positron)
  • Open command pallete with Ctrl + Shift + P
  • Type “Terminal:Select Default Profile”
  • Choose Git Bash for your default terminal

Git for macOS

  1. Check if Xcode command line tools is not installed (if installed, skip)
  • Open terminal
xcode-select --install
  1. Configure git, your name and email address
git config --global user.name "Your Name"
git config --global user.email "you@example.com"

# Confirm your setting
git config --global --list

Note

Important

  • You should also create an account on GitHub. Optionally, register with USF for a student previleges.

  • Check if terminal understands git command. Type git on terminal and confirm no error message.

Github Login

Make sure you are able to login to Github.

Introduction to Git/GitHub

Why do we need Git?

Git

  • Distributed version control system, created by Linus Torvalds (2005)

  • “Track changes” made by team members, merge into main, etc.

  • Considered a “must” for software development, and many data science projects.

  • Has a learning curve, but it’s worth learning even for solo projects.

GitHub

  • An online hosting platform that is based on Git system

  • Easy to browse other repositories (public, free)

  • Others: GitLab, Bitbucket, GitBucket, etc…

Why Git?

  • Version control: track changes, revert to previous versions

  • Collaboration: multiple people can work on the same project

  • Backup: store your project on the cloud

  • Portfolio: showcase your work to potential employers

  • Open source: contribute to other projects

Is Git same as GitHub?

Nope.

  • Git can be done completely locally (w/o internet).

  • GitHub deploys Git to online cloud system.

Does Git/Github work with any files?

Git is primarily designed to handle text files and tracks changes line by line.

  • It can upload binary files (e.g. images, pdfs), but doesn’t track differences like text files.

  • GitHub has a small file size limit (100MB)

  • It is intended for code tracking. Large data should be stored elsewhere.

Git Terminology/workflow

Why learn Git in this course?

On top of its practicality, it gives you hands-on experience & knowledge of cryptographic Merkle Tree algorithm.

  • Understand underlying mechanism of Blockchains

Blockchains:

  • Consensus algorithm (decentralized)
  • Merkle tree

Git shell commands

Git init

git init is used to initialize a new git repository from current working directory.

  • This command creates a new hidden subdirectory named .git
  • If you want to stop git, just remove this folder.
git init

Git status

git status shows the status of changes as untracked, modified, or staged.

git status

Understanding Git Status

git status provides information about the state of your working directory and staging area. Here are the key terms:

  • Untracked files: Files that Git isn’t tracking yet.

  • Tracked files: Files that Git has been monitoring for changes.

    • Staged: Files added to the staging area (using git add).
    • Unstaged: Modifications made to tracked files that haven’t been staged yet.
      • Includes “Modified(M)” and “Deleted(D)”

Git log

git log shows the history of commits and its corresponding hashes.

  • :q to quit!
git log
git log --oneline # brief view

Stage files

git add stages files for commit.

git add <filename> # stage specific files
git add . # stage all files (tracked / untracked)
git add -A # stage all (including parent and subfolders)
git add -u # stage only tracked files (modified, deleted)

Git reset (Unstaging)

git reset unstages all files and folders you added.

git reset # Unstages all

Make commit

git commit creates your project’s version, or a hash block.

You should provide message folling -m, that describes the version.

  • Consider committing a serious process of your job, like signing a doc.
git commit -m "Commit message, describes the work / version"

Exercise

1) My First Commit in Git

  1. Make class folder tracked by git (FIN4770)

  • Go to your folder from terminal.

  • In the Shell folder, create a text file For_first_commit.sh.

  • In the file, add text “Learing Git is Fun!”

  • Get out of Shell folder, and back to your class folder.

  • Now initiate git in your class folder.

  1. After initializing, git now “scans” your folder.
  • Check the status of git, with git status. What do you see?
  1. Let’s add all of the folders and files be tracked by git.
  • Use git add . to stage all untracked files and folders.
  • From now on, all those files are tracked.

  1. Now let’s make a commit.

    • By committing, you are making a version of the project.
    • You can come back to this state of your project in the future.
    • Make informative message in the commit!

For commit message, use “My first commit”.

  1. Check the status of git once again.

Git reset 2

git reset also can reset your previous commit.

  • You should mention the hash (id) of commit.
  • HEAD is a pointer where you are currently at.
  • HEAD~1 means 1 commit before current hash (version).

  1. git reset B

  • Changes made after B are “unstaged”
  • Go to the status where “Before I staged files and folders”
  • Same as git reset --mixed B
  1. git reset --soft B

  • Changes after B are “staged”
  • Go to the status where I was “Ready to commit again”
  1. git reset --hard B

  • Match completely to commit B, all others discarded.
  • Go to the status when I just finished committing B.
  • Be careful!! all changes after that are gone.

Exercise

Second commit & Reset

  1. Let’s make a faulty second commit then revert:

  • Go to your folder from terminal.

  • In the Shell folder, edit For_first_commit.sh file:

    • Append line: “Learning Git is Not Fun at all!”

  • Get out of Shell folder, and back to your class folder.

  • Then check the status. What do you see?

Remember this status. We will come back to here after reset.

  1. Add all changes to the staging area.

  2. Commit with message “Test second commit”

  • This is now your second version.

  1. Check the status.

  2. Check the commit logs with git log or git log --oneline.

  1. Now let’s get back to the previous version (Q1).
  • Run git reset HEAD~1
  • or git reset (hash)
  1. Check the status. Can you tell where you are?
  1. Let’s do the faulty second commit once again.
  • First add the change to the staging area git add .
  • Commit with message “Yet another test commit”
  • Check status and log to see where you are.
    • Make sure you are on the second commit.
  1. Let’s hard reset to status when we first committed.
  • We will remove all the changes made after the first commit.
  • Run git reset --hard HEAD~1.
  • Check the status and log. Confirm that your faulty edit is gone!

Set Remote repository

The process so far is only for your local version management, which is also completely fine for local work.

However, you can also make your repository “Synchronized” to a cloud server: Github.

git remote add adds remote repository.

  • origin is naming convention for Github remote repo.
  • main is your local branch name.

Let’s check the branch names first.

Exercise: Check branch

Let’s check the current local branch name. We use main branch named as “main”.

git branch

If your local branch name is not main (i.e. master or etc), change it to main with below command.

git branch -M main # Force move branch named as main

Add remote repository

Now we can add remote repository with following command.

git remote add <remote_name> <remote_url>

# example: Remote Repo named as origin
git remote add origin https://github.com/username/repositoryname

Exercise

2) My first push to GitHub

  1. Create your remote repository on Github website:

  • Go to the github website

  • Choose visibility to public

  • Name your repository nicely for this classroom

  • DO NOT ADD README FILE (leave it unchecked)

  • Copy the address to a text file

    • The address will be like https://github.com/YourGithubId/YourRepoName.git
  1. Add your remote repository address as “origin” branch
git remote add origin http:://github.com/YourGithubId/YourReponame.Git

From now on, you can browse your remote branches with

git remote
git remote -v # Verbose

git branch -a # list all branches

Push to repository

git push sends your commit to the remote repository.

# When pushing for the first time
git push -u origin main 

# From then 
git push

Exercise

Let’s push your local classrom git to the github.

Check first: 1) Your local status is clean (check with git status) 2) If not clean (You made edit after the initial version) stage changes and commit.

Then type below to push:

git push -u origin main

Homework

Browse your github site, and see files are uploaded.

https://github.com/yourGithubId/Reponame.git

  • Share the address to me.
Note

By default, git will only track files, not empty folders. Folders are tracked when files are in it.

Git clone

What if you wanted to download someone else’s remote repository to your local machine? Git clone is for the first time downloading from the remote repository.

git clone <repo_url>

# example
git clone https://github.com/example-user/example-repo.git

Exercise

Now let’s clone OUR CLASS repository (that I upload all class materials).

git clone action will create a folder and download everything from the upstream.

  • You should make a separate folder apart from your own class folder
  • Move one folder up from your class folder when you clone it.

Example: if your class folder address is ~/my_fin4770 then you should clone it from ~.

# Copy our class repository address below.
git clone https://github.com/INSTITUTION/CLASS-REPO.Git

Pull from repository

git pull downloads and apply changes from the repote repository.

git pull
Note

Actually, git pull does two things altogether:

  • fetch: download changes, but not apply the changes to local
  • If you want to see the differences between the two.
  • merge: apply changes to your local file

In-class Exercise

Now, I will make modify and update the class repositroy.

After the update, use git pull from the local class repo to apply the update.

Github and IDE

When using github from other apps (e.g. Positron, VScode, etc), you’ll use PAT (personal access token) instead of password.

Generate token from the github page, possibly with no expiration (or long enough)

  • Copy the token to clipboard (you won’t see the token again)
  • Store it somewhere temporarily

More Git concepts

Three pull method

By default, git pull is

git fetch # download update but do not apply changes to local
git merge # merge changes

git pull has three methods:

  • git pull --merge (default)

  • git pull --rebase

  • git pull --ff-only

git merge

Combines changes into a new merge commit. You will need to combine and resolve conflicts.

  • B, C are your local change

Example: Git merge scenario

Content of file.txt

Alice edits the second line and commits and push to main first:

Bob also edits the same line, but did not pull Alice’s changes. He edits and commits locally:

When Bob tries to push changes with git push, Git will reject because his local branch is behind the remote.

Bob runs git pull which is git fetch and git merge: git shows the conflicts

The file.txt now contains conflict markers

To resolve conflict, Bob should modify the file manually.

Bob stages this file and commits the resolution:

After resolving, Bob pushes with git push.

git rebase

Git replays your local branch on top of the remote branch, creating a linear history:

Example: Git rebase scenario

Content of file.txt

Alice edits the second line and commits and push to main first:

Bob also edits the same line, but did not pull Alice’s changes. He edits and commits locally:

When Bob tries to push changes with git push, Git will reject because his local branch is behind the remote.

Bob runs git pull --rebase which is git fetch and git rebase:

Instead of creating a merge commit,

  • git rewinds Bob’s local commit C

  • applies Alice’s changes from remote (origin/main) B

  • reapplies C on top of B

When there’s no conflict, (i.e., they did not change the same line of code) git pull –-rebase won’t raise any conflict message.

However, in our scenario, there’s conflict since both modified the same line, so:

  • rebase is halted

  • should be continued after conflict resolution

Similar to merge, conflict should be resolved manually.

The file.txt now contains conflict markers

To resolve conflict, Bob should modify the file manually.

Bob stages this file and continues the rebase (no commit)

git add file.txt
git rebase --continue

After that Bob pushes with git push. The history is linear.

git merge --ff-only

Used when you expect no conflicts.

When you want linear history and want to move your local branch pointer forward without modifying.

  • Git rejects if there is any conflict

.gitignore

Git keep tracks all changes within the project directory

  • New file, folder

  • Modifications (changes or updates)

  • Deletion

If there are files/folder you don’t want to track, specify them in .gitignore file.

git clean

If you want to remove untracked (not unstaged!) files:

git clean -nd # dry run (show what will be removed)
git clean -df # remove untracked files